package handler

import (
	"context"
	"github.com/gin-gonic/gin"
	"go-task/common"
	"go-task/data"
	"go-task/domain/dto"
	"go-task/domain/model"
	"go-task/task"
)

func Test(c *gin.Context) {
	common.Logger.Info("Test")
	taskGroup := "test"
	taskData := &data.TaskData{
		TaskId:    common.NewUUID(),
		TaskGroup: taskGroup,
		TaskName:  "test",
		Data:      "test",
		ExtendParam: map[string]string{
			"version": "1.0.0",
		},
	}
	msgData := &data.MsgData{
		Action: data.TASK,
		Data:   common.JsonString(taskData),
	}
	task.TaskManager.SendTask(taskGroup, common.EXCLUSIVE, msgData)
	common.OK(c)
}

func AddTask(c *gin.Context) {
	var addTaskDTO dto.AddTimeTaskDTO
	if err := c.ShouldBindJSON(&addTaskDTO); err != nil {
		common.BizError(c, err.Error())
		return
	}

	timeTask := &model.TimeTask{
		TaskId:          common.NewUUID(),
		TaskGroup:       addTaskDTO.TaskGroup,
		TaskName:        addTaskDTO.TaskName,
		TaskType:        addTaskDTO.TaskType,
		CronExpr:        addTaskDTO.CronExpr,
		SubType:         addTaskDTO.SubType,
		TaskData:        addTaskDTO.TaskData,
		TaskExtendParam: addTaskDTO.TaskExtendParam,
		TaskStatus:      common.TASK_STOP,
		CreateTime:      common.NowStr(),
		UpdateTime:      common.NowStr(),
	}

	if err := timeTask.AddTask(timeTask); err != nil {
		common.BizError(c, "添加任务失败")
		return
	}
	common.OK(c)
}

func TaskList(c *gin.Context) {
	var timeTask model.TimeTask
	taskList, err := timeTask.QueryList()
	if err != nil {
		common.BizError(c, err.Error())
		return
	}
	common.OKData(c, taskList)
}

func UpdateTaskStatus(c *gin.Context) {
	var updateTaskStatusDTO dto.UpdateTaskStatusDTO
	if err := c.ShouldBindJSON(&updateTaskStatusDTO); err != nil {
		common.BizError(c, err.Error())
		return
	}

	timeTask := &model.TimeTask{}
	queryTask, err := timeTask.QueryTask(updateTaskStatusDTO.TaskId)
	if err != nil || queryTask == nil {
		common.BizError(c, "任务数据不存在")
		return
	}

	if updateTaskStatusDTO.TaskStatus == common.TASK_RUN {
		updateErr := timeTask.UpdateTaskStatus(queryTask.TaskId, common.TASK_RUN, func() error {
			taskErr := task.TM.AddTask(context.Background(), queryTask)
			return taskErr
		})
		if updateErr != nil {
			common.BizError(c, updateErr.Error())
			return
		}
	}

	if updateTaskStatusDTO.TaskStatus == common.TASK_STOP {
		updateErr := timeTask.UpdateTaskStatus(queryTask.TaskId, common.TASK_STOP, func() error {
			return task.TM.StopTask(queryTask.TaskId)
		})
		if updateErr != nil {
			common.BizError(c, updateErr.Error())
			return
		}
	}

	common.OK(c)
}

func DeleteTask(c *gin.Context) {
	var deleteTaskDTO dto.DeleteTaskDTO
	if err := c.ShouldBindJSON(&deleteTaskDTO); err != nil {
		common.BizError(c, err.Error())
		return
	}

	var timeTask model.TimeTask
	err := timeTask.DeleteTask(deleteTaskDTO.TaskId)
	if err != nil {
		common.BizError(c, err.Error())
		return
	}
	err = task.TM.StopTask(deleteTaskDTO.TaskId)
	if err != nil {
		common.Logger.Infof("stop task err:%v", err)
	}
	common.OK(c)
}

func ExecTaskTest(c *gin.Context) {
	var addTaskDTO dto.AddTimeTaskDTO
	if err := c.ShouldBindJSON(&addTaskDTO); err != nil {
		common.BizError(c, err.Error())
		return
	}

	taskData := &data.TaskData{
		TaskId:    common.NewUUID(),
		TaskGroup: addTaskDTO.TaskGroup,
		TaskName:  addTaskDTO.TaskName,
		Data:      addTaskDTO.TaskData,
	}

	if len(addTaskDTO.TaskExtendParam) > 0 {
		var extendParam map[string]string
		common.ParseJson(addTaskDTO.TaskExtendParam, &extendParam)
		taskData.ExtendParam = extendParam
	}

	msgData := &data.MsgData{
		Action: data.TASK,
		Data:   common.JsonString(taskData),
	}
	task.TaskManager.SendTask(addTaskDTO.TaskGroup, addTaskDTO.SubType, msgData)
	common.OK(c)
}
